home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / st-infru.c < prev    next >
C/C++ Source or Header  |  1992-03-25  |  34KB  |  1,168 lines
  1. /* this one hacked up for st by jrd */
  2.  
  3. /* Start and stop the inferior process, for GDB.
  4.    Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
  5.  
  6. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  7. WARRANTY.  No author or distributor accepts responsibility to anyone
  8. for the consequences of using it or for whether it serves any
  9. particular purpose or works at all, unless he says so in writing.
  10. Refer to the GDB General Public License for full details.
  11.  
  12. Everyone is granted permission to copy, modify and redistribute GDB,
  13. but only under the conditions described in the GDB General Public
  14. License.  A copy of this license is supposed to have been given to you
  15. along with GDB so you can know your rights and responsibilities.  It
  16. should be in a file named COPYING.  Among other things, the copyright
  17. notice and this notice must be preserved on all copies.
  18.  
  19. In other words, go ahead and share GDB, but don't try to stop
  20. anyone else from sharing it farther.  Help stamp out software hoarding!
  21. */
  22.  
  23. #include "defs.h"
  24. #include "param.h"
  25. #include "symtab.h"
  26. #include "frame.h"
  27. #include "inferior.h"
  28. #include "wait.h"
  29.  
  30. #include <stdio.h>
  31. #include <signal.h>
  32.  
  33. #include <st-out.h>
  34.  
  35. extern char *sys_siglist[];
  36. extern int errno;
  37.  
  38. /* Tables of how to react to signals; the user sets them.  */
  39.  
  40. static char signal_stop[NSIG];
  41. static char signal_print[NSIG];
  42. static char signal_program[NSIG];
  43.  
  44. /* Nonzero if breakpoints are now inserted in the inferior.  */
  45.  
  46. static int breakpoints_inserted;
  47.  
  48. /* Function inferior was in as of last step command.  */
  49.  
  50. static struct symbol *step_start_function;
  51.  
  52. /* This is the sequence of bytes we insert for a breakpoint.  */
  53.  
  54. static char break_insn[] = BREAKPOINT;
  55.  
  56. /* Nonzero => address for special breakpoint for resuming stepping.  */ 
  57.  
  58. static CORE_ADDR step_resume_break_address;
  59.  
  60. /* Original contents of the byte where the special breakpoint is.  */
  61.  
  62. static char step_resume_break_shadow[sizeof break_insn];
  63.  
  64. /* Nonzero means the special breakpoint is a duplicate
  65.    so it has not itself been inserted.  */
  66.  
  67. static int step_resume_break_duplicate;
  68.  
  69. /* Nonzero if we are expecting a trace trap and should proceed from it.
  70.    2 means expecting 2 trace traps and should continue both times.
  71.    That occurs when we tell sh to exec the program: we will get
  72.    a trap after the exec of sh and a second when the program is exec'd.  */
  73.  
  74. static int trap_expected;
  75.  
  76. /* Nonzero if the next time we try to continue the inferior, it will
  77.    step one instruction and generate a spurious trace trap.
  78.    This is used to compensate for a bug in HP-UX.  */
  79.  
  80. static int trap_expected_after_continue;
  81.  
  82. /* Nonzero means expecting a trace trap
  83.    and should stop the inferior and return silently when it happens.  */
  84.  
  85. static int stop_after_trap;
  86.  
  87. /* Nonzero means expecting a trace trap due to attaching to a process.  */
  88.  
  89. static int stop_after_attach;
  90.  
  91. /* Nonzero if pc has been changed by the debugger
  92.    since the inferior stopped.  */
  93.  
  94. int pc_changed;
  95.  
  96. /* Nonzero if proceed is being used for a "finish" command or a similar
  97.    situation when stop_registers should be saved.  */
  98.  
  99. int proceed_to_finish;
  100.  
  101. /* Nonzero if debugging a remote machine via a serial link or ethernet.  */
  102.  
  103. int remote_debugging;
  104.  
  105. /* Save register contents here when about to pop a stack dummy frame.  */
  106.  
  107. char stop_registers[REGISTER_BYTES];
  108.  
  109. /* Nonzero if program stopped due to error trying to insert breakpoints.  */
  110.  
  111. static int breakpoints_failed;
  112.  
  113. /* Nonzero if inferior is in sh before our program got exec'd.  */
  114.  
  115. static int running_in_shell;
  116.  
  117. /* Nonzero after stop if current stack frame should be printed.  */
  118.  
  119. static int stop_print_frame;
  120.  
  121. static void insert_step_breakpoint ();
  122. static void remove_step_breakpoint ();
  123. static void wait_for_inferior ();
  124. static void normal_stop ();
  125.  
  126.  
  127. /* Clear out all variables saying what to do when inferior is continued.
  128.    First do this, then set the ones you want, then call `proceed'.  */
  129.  
  130. void
  131. clear_proceed_status ()
  132. {
  133.   trap_expected = 0;
  134.   step_range_start = 0;
  135.   step_range_end = 0;
  136.   step_frame = 0;
  137.   step_over_calls = -1;
  138.   step_resume_break_address = 0;
  139.   stop_after_trap = 0;
  140.   stop_after_attach = 0;
  141.   proceed_to_finish = 0;
  142.  
  143.   /* Discard any remaining commands left by breakpoint we had stopped at.  */
  144.   clear_breakpoint_commands ();
  145. }
  146.  
  147. /* Basic routine for continuing the program in various fashions.
  148.  
  149.    ADDR is the address to resume at, or -1 for resume where stopped.
  150.    SIGNAL is the signal to give it, or 0 for none,
  151.      or -1 for act according to how it stopped.
  152.    STEP is nonzero if should trap after one instruction.
  153.      -1 means return after that and print nothing.
  154.      You should probably set various step_... variables
  155.      before calling here, if you are stepping.
  156.  
  157.    You should call clear_proceed_status before calling proceed.  */
  158.  
  159. void
  160. proceed (addr, signal, step)
  161.      CORE_ADDR addr;
  162.      int signal;
  163.      int step;
  164. {
  165.   int oneproc = 0;
  166.  
  167.   if (step > 0)
  168.     step_start_function = find_pc_function (read_pc ());
  169.   if (step < 0)
  170.     stop_after_trap = 1;
  171.  
  172.   if (addr == -1)
  173.     {
  174.       /* If there is a breakpoint at the address we will resume at,
  175.      step one instruction before inserting breakpoints
  176.      so that we do not stop right away.  */
  177.  
  178.       if (!pc_changed && breakpoint_here_p (read_pc ()))
  179.     oneproc = 1;
  180.     }
  181.   else
  182.     write_register (PC_REGNUM, addr);
  183.  
  184.   if (trap_expected_after_continue)
  185.     {
  186.       /* If (step == 0), a trap will be automatically generated after
  187.      the first instruction is executed.  Force step one
  188.      instruction to clear this condition.  This should not occur
  189.      if step is nonzero, but it is harmless in that case.  */
  190.       oneproc = 1;
  191.       trap_expected_after_continue = 0;
  192.     }
  193.  
  194.   if (oneproc)
  195.     /* We will get a trace trap after one instruction.
  196.        Continue it automatically and insert breakpoints then.  */
  197.     trap_expected = 1;
  198.   else
  199.     {
  200.       int temp = insert_breakpoints ();
  201.       if (temp)
  202.     {
  203.       print_sys_errmsg ("ptrace", temp);
  204.       error ("Cannot insert breakpoints.\n\
  205. The same program may be running in another process.");
  206.     }
  207.       breakpoints_inserted = 1;
  208.     }
  209.  
  210.   /* Install inferior's terminal modes.  */
  211.   terminal_inferior ();
  212.  
  213.   if (signal >= 0)
  214.     stop_signal = signal;
  215.   /* If this signal should not be seen by program,
  216.      give it zero.  Used for debugging signals.  */
  217.   else if (stop_signal < NSIG && !signal_program[stop_signal])
  218.     stop_signal= 0;
  219.  
  220.   /* Resume inferior.  */
  221.   resume (oneproc || step, stop_signal);
  222.  
  223.   /* Wait for it to stop (if not standalone)
  224.      and in any case decode why it stopped, and act accordingly.  */
  225.  
  226.   wait_for_inferior ();
  227.   normal_stop ();
  228. }
  229.  
  230. /* Writing the inferior pc as a register calls this function
  231.    to inform infrun that the pc has been set in the debugger.  */
  232.  
  233. writing_pc (val)
  234.      CORE_ADDR val;
  235. {
  236.   stop_pc = val;
  237.   pc_changed = 1;
  238. }
  239.  
  240. /* Start an inferior process for the first time.
  241.    Actually it was started by the fork that created it,
  242.    but it will have stopped one instruction after execing sh.
  243.    Here we must get it up to actual execution of the real program.  */
  244.  
  245. start_inferior ()
  246. {
  247.   /* We will get a trace trap after one instruction.
  248.      Continue it automatically.  Eventually (after shell does an exec)
  249.      it will get another trace trap.  Then insert breakpoints and continue.  */
  250.   trap_expected = 2;
  251.   running_in_shell = 0;        /* Set to 1 at first SIGTRAP, 0 at second.  */
  252.   trap_expected_after_continue = 0;
  253.   breakpoints_inserted = 0;
  254.   mark_breakpoints_out ();
  255.  
  256.   /* Set up the "saved terminal modes" of the inferior
  257.      based on what modes we are starting it with.  */
  258.   terminal_init_inferior ();
  259.  
  260.   /* Install inferior's terminal modes.  */
  261.   terminal_inferior ();
  262.  
  263.   if (remote_debugging)
  264.     {
  265.       trap_expected = 0;
  266.       fetch_inferior_registers();
  267.       set_current_frame (read_register(FP_REGNUM));
  268.       stop_frame = get_current_frame();
  269.       inferior_pid = 3;
  270.       if (insert_breakpoints())
  271.     fatal("Can't insert breakpoints");
  272.       breakpoints_inserted = 1;
  273.       proceed(-1, -1, 0);
  274.     }
  275.   else
  276.     {
  277.       wait_for_inferior ();
  278.       normal_stop ();
  279.     }
  280. }
  281.  
  282. /* Start remote-debugging of a machine over a serial link.  */
  283.  
  284. void
  285. start_rem